home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / DClap / Dvibrant.c < prev    next >
Text File  |  1996-07-05  |  20KB  |  741 lines
  1. /* Dvibrant.c */
  2. /* dgg additions to ncbi/vibrant */
  3.  
  4.  
  5. #include "Dvibrant.h"
  6.  
  7. #ifdef COMP_CWI
  8. #define _asm  asm
  9. #endif
  10.  
  11. #include <ncbi.h>
  12. #include <ncbidraw.h>
  13. #include <ncbiwin.h>
  14. #include <ncbiport.h>
  15. #include <vibincld.h>
  16.  
  17. void Dgg_PenNormal()  /* nlmdraw addition */
  18. {
  19.     Nlm_Black();
  20.     Nlm_Solid();
  21.     Nlm_WidePen(1); /* << !? need Nlm_PenNormal() */
  22. }
  23.  
  24. extern void Dgg_DrawTextbox (Nlm_RectPtr r, Nlm_CharPtr text,
  25.                                ulong len, Nlm_Char jst, Nlm_Boolean gray)
  26. {
  27. /* from Nlm_DrawText which mostly does this, but XWin XDrawString primitive doesn't know about
  28.    multiline text */
  29.    
  30. #ifdef WIN_MAC
  31.   Nlm_Int2      just;
  32.   PenState      pnState;
  33.   Nlm_RectTool  rtool;
  34.  
  35.   if (r != NULL) {
  36.     Nlm_EraseRect (r);
  37.     if (text != NULL && len > 0) {
  38.       Nlm_RecTToRectTool (r, &rtool);
  39.       switch (jst) {
  40.         case 'r':
  41.           just = -1;
  42.           break;
  43.         case 'l':
  44.           just = 0;
  45.           break;
  46.         case 'c':
  47.           just = 1;
  48.           break;
  49.         default:
  50.           just = 0;
  51.           break;
  52.       }
  53.       TextBox (text, len, &rtool, just);
  54.       if (gray) {
  55.         GetPenState (&pnState);
  56.         PenMode (patBic);
  57.         /*PenPat ((ConstPatternParam) grayPat);*/
  58.                 Nlm_Medium();
  59.         PaintRect (&rtool);
  60.         SetPenState (&pnState);
  61.       }
  62.     }
  63.   }
  64. #endif
  65. #ifdef WIN_MSWIN
  66.   Nlm_Int2      format;
  67.   Nlm_Int4      oldcolor;
  68.   Nlm_RectTool  rtool;
  69.  
  70.   if (r != NULL && Nlm_currentHDC != NULL) {
  71.     Nlm_RecTToRectTool (r, &rtool);
  72.     if (Nlm_currentHWnd != NULL) {
  73.       Nlm_EraseRect (r);
  74.     } else {
  75.       FillRect (Nlm_currentHDC, &rtool, GetStockObject (WHITE_BRUSH));
  76.     }
  77.     if (text != NULL && len > 0) {
  78.       switch (jst) {
  79.         case 'r':
  80.           format = DT_RIGHT;
  81.           break;
  82.         case 'l':
  83.           format = DT_LEFT;
  84.           break;
  85.         case 'c':
  86.           format = DT_CENTER;
  87.           break;
  88.         default:
  89.           format = DT_LEFT;
  90.           break;
  91.       }
  92.       if (gray) {
  93.         oldcolor = SetTextColor (Nlm_currentHDC, GetSysColor (COLOR_GRAYTEXT));
  94.       }
  95.       DrawText (Nlm_currentHDC, text, (Nlm_Int2) len, &rtool,
  96.                 format | DT_VCENTER | DT_NOPREFIX);
  97.       if (gray) {
  98.         SetTextColor (Nlm_currentHDC, oldcolor);
  99.       }
  100.     }
  101.   }
  102. #endif
  103.  
  104. #ifdef WIN_MOTIF
  105.   Nlm_Int2   delta;
  106.   Nlm_Int2   height;
  107.   Nlm_Int2   limit;
  108.   Pixmap     pix;
  109.   Nlm_PoinT  pt;
  110.   Nlm_Int2   width;
  111.  
  112.   if (r != NULL && Nlm_currentXDisplay != NULL &&
  113.       Nlm_currentXWindow != 0 && Nlm_currentXGC != NULL) {
  114.     Nlm_EraseRect (r);
  115.     if (text != NULL && len > 0) {
  116.             Nlm_Int4  widlimit, pixwid, linewid, nlines;
  117.             Nlm_Int2    atx, liney;
  118.             char    *cp, *cp0;
  119.             
  120.       pt.x = r->left - Nlm_XOffset;
  121.       pt.y = r->top - Nlm_YOffset;
  122.             nlines= 0;
  123.             cp0= text;
  124.             do {
  125.                 nlines++;
  126.                 cp= Nlm_StrChr(cp0, '\n');  
  127.                 if (cp) cp0= 1 + cp;
  128.             } while (cp);
  129.  
  130.          width= 0;
  131.         widlimit = ABS(r->right - r->left);
  132.             limit = ABS(r->bottom - r->top);
  133.       height = Nlm_LineHeight();
  134.             delta = limit - nlines * height; 
  135.             if (delta > 0) pt.y += delta / 2;   
  136.             liney= pt.y + Nlm_Ascent();
  137.             
  138.             cp0= text;
  139.         if (gray) Nlm_Medium();
  140.             do {
  141.                 nlines++;
  142.                 cp= Nlm_StrChr(cp0, '\n');  
  143.                 if (cp) linewid= cp - cp0;
  144.                 else linewid= len - (cp0 - text);
  145.                     
  146.                 pixwid= Nlm_TextWidth (cp0, linewid);
  147.                 if (pixwid > widlimit) {
  148.                     linewid= Min(linewid, 1 + widlimit / Nlm_MaxCharWidth());
  149.                     pixwid= Nlm_TextWidth(cp0, linewid);
  150.                     while (linewid > 0 && pixwid > widlimit) {
  151.                 linewid--;
  152.                 pixwid = Nlm_TextWidth (cp0, linewid);
  153.                   }
  154.                     }
  155.                 
  156.                 delta = widlimit - pixwid;
  157.                 if (delta>0) switch (jst) {
  158.                     case 'r':
  159.                         atx = pt.x + delta;
  160.                         break;
  161.                     default:
  162.                     case 'l':
  163.                         atx = pt.x;
  164.                         break;
  165.                     case 'c':
  166.                         atx = pt.x + delta / 2;
  167.                         break;
  168.                     }
  169.                  
  170.                 XDrawString (Nlm_currentXDisplay, Nlm_currentXWindow, Nlm_currentXGC,
  171.                                          atx, liney, cp0, (int) linewid);
  172.                 liney += height; 
  173.                 
  174.                 if (cp) {
  175.                     if (linewid < cp - cp0) cp0 += linewid; 
  176.                     else cp0 = 1+cp;
  177.                     }
  178.                 else if (cp0 + linewid < text + len) {
  179.                     cp0= cp0 + linewid;
  180.                     cp= cp0;
  181.                     }
  182.             } while (cp);
  183.     if (gray) Nlm_Solid();
  184.     
  185.     }
  186.   }
  187. #endif
  188. }
  189.  
  190.  
  191.  
  192.  
  193. extern void Dgg_SetParentWindow (Nlm_GraphiC a, Nlm_WindoW newwindow)
  194. {
  195.   Nlm_GraphiC  child, g, p;
  196.  
  197.   g = a;
  198.   if (a != NULL) {
  199.           child= g;
  200.     p = Nlm_GetParent (g);
  201.     while (p != NULL) {
  202.                child= g;
  203.       g = p;
  204.       p = Nlm_GetParent (g);
  205.     }
  206.   /* g == window, child == a primary subview in window */
  207.   if (child != NULL) Nlm_SetParent( child, (Nlm_GraphiC) newwindow);
  208.   }
  209. }
  210.  
  211.  
  212.  
  213. #ifdef WIN_MAC
  214.  
  215. /* LaunchFileThruFinder perpares and sends the Finder OpenSelection event */
  216.  
  217. #include <Processes.h>
  218. #include <GestaltEqu.h>
  219. #include <AppleEvents.h>
  220. #include <Aliases.h>
  221.  
  222.  
  223.         // from MacAppUtilities.cp
  224. OSErr FindProcessBySignature(OSType sig, ProcessSerialNumber* psn, FSSpec* fileSpec)
  225. {
  226.     OSErr err;
  227.     ProcessInfoRec info;
  228.  
  229.     psn->highLongOfPSN = 0;
  230.     psn->lowLongOfPSN  = kNoProcess;
  231.     do {
  232.         err= GetNextProcess(psn);
  233.         if( err == noErr ) {
  234.             info.processInfoLength = sizeof(ProcessInfoRec);
  235.             info.processName = NULL;
  236.             info.processAppSpec = fileSpec;
  237.             err= GetProcessInformation(psn, &info);
  238.         }
  239.     } while( (err == noErr) && info.processSignature != sig );
  240.  
  241.     if( err == noErr ) (*psn) = info.processNumber;
  242.  
  243.     return err;
  244. }  
  245.  
  246.  
  247. OSErr LaunchFileSpecThruFinder( FSSpec fileToLaunch)
  248. {                    
  249.     const        OSType aeSelectionKeyword    = 'fsel';
  250.     const        OSType kAEOpenSelection        = 'sope';
  251.     const        OSType kFinderType                 = 'FNDR';
  252.     const        OSType kSysCreator                 = 'MACS';
  253.     
  254.     AppleEvent    aeEvent, aeReply;
  255.     AEDesc            myAddressDesc, aeDirDesc, listElem;
  256.     FSSpec            dirSpec, procSpec;
  257.     AEDesc            fileList;
  258.     OSErr                myErr;
  259.     ProcessSerialNumber        finderSN;
  260.     AliasHandle    DirAlias, FileAlias;
  261.                 
  262.     DirAlias= NULL;
  263.     FileAlias= NULL;
  264.     aeEvent.dataHandle= NULL;
  265.     
  266.         // find the finder on this machine 
  267. // failing here w/ no finder !?
  268.     myErr= FindProcessBySignature(kFinderType, &finderSN, &procSpec);
  269. //    if (myErr!=0) return procNotFound;
  270.     if (myErr != 0) { // do the hard way...
  271.         ProcessSerialNumber    processSN;
  272.     ProcessInfoRec infoRec;
  273.     Str31 processName;
  274.     FSSpec procSpec;
  275.     Boolean notFinder = true;
  276.  
  277.     processSN.lowLongOfPSN = kNoProcess;
  278.     processSN.highLongOfPSN = kNoProcess;
  279.         do {
  280.         myErr = GetNextProcess(&processSN);
  281.                 infoRec.processInfoLength = sizeof(ProcessInfoRec);
  282.                 infoRec.processName = (StringPtr)&processName;
  283.                 infoRec.processAppSpec = &procSpec;
  284.         GetProcessInformation(&processSN, &infoRec);
  285.                 if (infoRec.processSignature == kSysCreator 
  286.                  && infoRec.processType == kFinderType) {
  287.                     finderSN = processSN;
  288.                     notFinder = false;
  289.                     }
  290.             } while (notFinder && !myErr);    
  291.         }
  292.         
  293.         
  294.     myErr= AECreateDesc(typeProcessSerialNumber, (Ptr) &finderSN, sizeof(finderSN), 
  295.                                                 &myAddressDesc);
  296.     if (myErr != noErr) return myErr;
  297.     
  298.             // Create the FinderEvent 
  299.     myErr= AECreateAppleEvent(kFinderType, kAEOpenSelection, &myAddressDesc, 
  300.                                             kAutoGenerateReturnID, kAnyTransactionID, &aeEvent);
  301.     if (myErr != noErr) return myErr;
  302.     
  303.     // Now we build all the bits of an OpenSelection event. 
  304.     //  Basically, we need to create an alias for the item to open, and an alias to the parent 
  305.     // folder (directory) of that item.  We can also pass a list of files if we want.  
  306.     // Youll notice that for opening a finder window, the file and directory alias both point at the 
  307.     // folder itself. Make a spec for the parent folder  
  308.      
  309.         //  create the folder descriptor 
  310.     myErr= FSMakeFSSpec( fileToLaunch.vRefNum, fileToLaunch.parID, NULL, &dirSpec);
  311.     
  312.     myErr= NewAlias( NULL, &dirSpec, &DirAlias);
  313.     HLock( (Handle) DirAlias);
  314.     myErr= AECreateDesc(typeAlias, (Ptr) *DirAlias, GetHandleSize( (Handle) DirAlias), 
  315.                                 &aeDirDesc);
  316.     HUnlock( (Handle)DirAlias);
  317.     DisposHandle( (Handle) DirAlias);
  318.     
  319.     myErr= AEPutParamDesc( &aeEvent, keyDirectObject, &aeDirDesc);
  320.     if (myErr != noErr) return myErr;
  321.     myErr= AEDisposeDesc( &aeDirDesc);
  322.     
  323.             // create the file descriptor and add to aliasList 
  324.     myErr= NewAlias( NULL, &fileToLaunch, &FileAlias);
  325.     HLock( (Handle)FileAlias);
  326.     myErr= AECreateDesc(typeAlias, (Ptr)*FileAlias, GetHandleSize( (Handle)FileAlias), 
  327.                                     &listElem);
  328.     HUnlock( (Handle)FileAlias);
  329.     DisposHandle( (Handle)FileAlias);
  330.     
  331.         // Create the file  list 
  332.     myErr= AECreateList(NULL, 0, false, &fileList);
  333.     if (myErr != noErr) return myErr;
  334.     
  335.     myErr= AEPutDesc( &fileList, 0, &listElem);
  336.     (void) AEDisposeDesc( &listElem);
  337.     if (myErr != noErr) return myErr;
  338.     
  339.         // Add the file alias list to the event 
  340.     myErr= AEPutParamDesc( &aeEvent, aeSelectionKeyword, &fileList);
  341.     (void) AEDisposeDesc( &fileList);
  342.     if (myErr != noErr) return myErr;
  343.  
  344.     myErr= AESend( &aeEvent, &aeReply, kAENoReply + kAEAlwaysInteract + kAECanSwitchLayer,
  345.                                          kAENormalPriority, kAEDefaultTimeout, NULL, NULL);
  346.         
  347.     (void) AEDisposeDesc( &aeEvent);
  348.     return myErr;
  349. }
  350.  
  351. #endif
  352.  
  353.  
  354.  
  355. const char*  MacDirIDtoName( short vRefNum, long dirID, char* fname)
  356. {
  357. #ifdef WIN_MAC
  358.     static char    directory[PATH_MAX];
  359.   char     temp[PATH_MAX], * tmp;
  360.   CInfoPBRec   params;
  361.     short        err;
  362.     
  363.   temp[0] = '\0';
  364.   params.dirInfo.ioNamePtr = (StringPtr) directory;
  365.   params.dirInfo.ioDrParID = dirID;
  366.   do {
  367.     params.dirInfo.ioVRefNum = vRefNum;
  368.     params.dirInfo.ioFDirIndex = -1;
  369.     params.dirInfo.ioDrDirID = params.dirInfo.ioDrParID;
  370.     err = PBGetCatInfo (¶ms, FALSE);
  371. #ifdef COMP_THINKC
  372.         PtoCstr ((StringPtr) directory);
  373. #else
  374.         p2cstr ((StringPtr) directory);
  375. #endif
  376.     Nlm_StringCat(directory, DIRDELIMSTR);
  377.     Nlm_StringCat(directory, temp);
  378.     Nlm_StringCpy(temp, directory);
  379.   } while (params.dirInfo.ioDrDirID != fsRtDirID);
  380.  
  381.   tmp = Nlm_StringMove(directory, temp);
  382.   tmp = Nlm_StringMove(tmp, fname);
  383.   return directory;
  384. #else
  385.     return NULL;
  386. #endif
  387. } 
  388.  
  389.  
  390.  
  391. typedef void (*FileFunc)(const char*);
  392.  
  393. short HandleFileEvent( long inEvent, long outReply, long inNumber,
  394.                                             long fileFunc)
  395. {                    
  396. #ifdef WIN_MAC
  397.     AppleEvent    *aeEvent, *aeReply;
  398.     AEDescList    docList;            
  399.     short                err;
  400.     long                nitems, item;
  401.     FileFunc    * callFileFunc;
  402.     
  403.     if (!inEvent || !fileFunc) return;
  404.     aeEvent = (AppleEvent*) inEvent;
  405.     aeReply = (AppleEvent*) outReply;
  406.     callFileFunc = (FileFunc*) fileFunc;
  407.     
  408.     err= AEGetParamDesc( aeEvent, keyDirectObject, typeAEList, &docList);
  409.     if (err) return;
  410.     err= AECountItems( &docList, &nitems);
  411.     if (err) return;
  412.     for (item= 1; item<=nitems; item++) {
  413.         AEKeyword        keywd;
  414.         DescType        returnedType;
  415.         FSSpec            aFileSpec;
  416.         Size                actualSize;
  417.         const char * pathname;
  418.         
  419.         err= AEGetNthPtr( &docList, item, typeFSS, &keywd, &returnedType,
  420.                                             (void*)&aFileSpec, sizeof(aFileSpec), &actualSize);
  421.         if (err) break; // continue ?
  422.         
  423. #ifdef COMP_THINKC
  424.         PtoCstr ((StringPtr) aFileSpec.name);
  425. #else
  426.         p2cstr ((StringPtr) aFileSpec.name);
  427. #endif
  428.         pathname= MacDirIDtoName( aFileSpec.vRefNum, aFileSpec.parID,
  429.                                                          (char*) aFileSpec.name);
  430.         (*callFileFunc)( pathname); // this->OpenDocument( filename);
  431.         }
  432.     (void) AEDisposeDesc( &docList);
  433.     return err;
  434. #else
  435.     return -1;
  436. #endif
  437. }
  438.  
  439.  
  440.  
  441. #ifdef WIN_MAC
  442. /* quick hack to check child apps by psn */
  443. ProcessSerialNumber  gChildProcessSN;
  444. #else
  445. long         gChildProcessSN;
  446. #endif
  447.  
  448.  
  449. char* Fullpathname( char* filename, Nlm_Boolean forceprogpath)
  450. {
  451.     static char    pathname [512]; /* ?? is there a 256 char limit on mac paths ?? */
  452.   Nlm_CharPtr          ptr;
  453.   Nlm_Boolean addpath;
  454.   
  455.   addpath= forceprogpath 
  456.     || (Nlm_StringChr(filename, DIRDELIMCHR) == NULL);
  457. #ifdef WIN_MSWIN
  458.   if (filename[1] == ':' || filename[0] == DIRDELIMCHR)
  459.     addpath= false;
  460. #endif
  461. #ifdef OS_UNIX
  462.   if (filename[0] == DIRDELIMCHR) addpath= false;
  463. #endif
  464.  
  465.     if (!addpath) 
  466.         Nlm_StringNCpy ((Nlm_CharPtr) pathname, filename, sizeof (pathname));
  467.     else {
  468.         Nlm_ProgramPath((Nlm_CharPtr) pathname, sizeof (pathname));
  469.         ptr = Nlm_StringRChr((Nlm_CharPtr) pathname, DIRDELIMCHR);
  470.         if (ptr)  *ptr = '\0';
  471.         Nlm_FileBuildPath((Nlm_CharPtr) pathname, NULL, filename);
  472.         }
  473.     return pathname;
  474. }
  475.  
  476.  
  477.  
  478. extern Nlm_Boolean Dgg_LaunchApp( char* appName, char* commandline,
  479.                                                     char* Stdin, char* Stdout, char* Stderr)
  480. {
  481. #ifdef WIN_MAC
  482.   OSErr                              err;
  483.   FSSpec               fsspec;
  484.   long                 gval;
  485.   LaunchParamBlockRec  lparm;
  486.     //unsigned char *      pathname[256];  
  487.   Nlm_CharPtr          pathname, ptr;
  488.   Nlm_Boolean          rsult;
  489.  
  490.   rsult = FALSE;
  491.   if (Gestalt (gestaltSystemVersion, &gval) == noErr && (short) gval >= 7 * 256) {
  492.     if (appName && *appName) {
  493.             pathname= Fullpathname( appName, false);
  494.             Nlm_CtoPstr((Nlm_CharPtr) pathname);
  495.             err = FSMakeFSSpec(0, 0, (unsigned char*)pathname, &(fsspec));
  496.             
  497.             if (Stdin || Stdout || Stderr) {
  498.                 if (!commandline) commandline= MemNew(1);
  499.                 if (Stdin) {
  500.                     pathname= Fullpathname(Stdin,false);
  501.                     commandline= MemMore( commandline, StrLen(commandline) + 6 + StrLen(pathname));
  502.                     StrCat( commandline, " < '");
  503.                     StrCat( commandline, pathname);
  504.                     StrCat( commandline, "'");
  505.                     }
  506.                 if (Stdout) {
  507.                     pathname= Fullpathname(Stdout,false);
  508.                     commandline= MemMore( commandline, StrLen(commandline) + 6 + StrLen(pathname));
  509.                     StrCat( commandline, " > '");
  510.                     StrCat( commandline, pathname);
  511.                     StrCat( commandline, "'");
  512.                     }
  513.                 if (Stderr) {
  514.                     pathname= Fullpathname(Stderr,false);
  515.                     commandline= MemMore( commandline, StrLen(commandline) + 6 + StrLen(pathname));
  516.                     StrCat( commandline, " 2> '");
  517.                     StrCat( commandline, pathname);
  518.                     StrCat( commandline, "'");
  519.                     }
  520.                 }
  521.                 
  522.             if (commandline) {
  523.                 /* only good for launching an application, not a document... */
  524.                 EventRecord hlevt;
  525.               AppParametersPtr appParams;
  526.                 long    len;
  527.  
  528.                 MemSet( &lparm, 0, sizeof(lparm));
  529.               len= 2 + StrLen(appName) + StrLen( commandline);
  530.                 hlevt.what= kHighLevelEvent;
  531.                 hlevt.message= 'DClp'; // ID of sender == DClap application
  532.                 hlevt.where.v= 'Cm';  
  533.                 hlevt.where.h= 'dl'; //(Point)'Cmdl';     // command line event type
  534.                 
  535.               appParams= (AppParametersPtr) MemNew( sizeof(AppParameters) + len + 2);
  536.                 appParams->theMsgEvent= hlevt;
  537.                 appParams->eventRefCon= 'Cmdl'; // ?? again
  538.                 ptr= (char*) &(appParams->messageLength) + sizeof(long);
  539.                 StrCpy( ptr, appName);
  540.                 StrCat( ptr, " ");
  541.                 StrCat( ptr, commandline); 
  542.                 appParams->messageLength= len;
  543.                 lparm.launchAppParameters = appParams;
  544.                     
  545.                 lparm.launchBlockID = extendedBlock;
  546.                 lparm.launchEPBLength = extendedBlockLen;
  547.                 lparm.launchFileFlags = 0;
  548.                 lparm.launchControlFlags = launchContinue + launchNoFileFlags;
  549.                 lparm.launchAppSpec = &fsspec;
  550.                 err= LaunchApplication (&lparm);
  551.                 rsult= (err == noErr);
  552.                 gChildProcessSN= lparm.launchProcessSN;
  553.                 
  554.                 MemFree( appParams);
  555.                 }
  556.             else {
  557.                  rsult = (Nlm_Boolean) (LaunchFileSpecThruFinder( fsspec)  == noErr);
  558.                  }
  559.         }
  560.       }
  561.   return rsult;
  562. #endif
  563.  
  564. #ifdef WIN_MSWIN
  565.   Nlm_Char     ch;
  566.   Nlm_Int2     i, j, k;
  567.   Nlm_Uint2         val;
  568.   char         lpszCmdLine[256];
  569.   char      *  pathname, *ptail;
  570.   Nlm_Boolean  rsult;
  571.  
  572.   rsult = FALSE;
  573.   if ((appName && *appName) || (commandline && *commandline)) {
  574.   
  575.         if (Stdin || Stdout || Stderr) {
  576.             if (!commandline) commandline= MemNew(1);
  577.             if (Stdin) {
  578.                 pathname= Fullpathname(Stdin,false);
  579.                 commandline= MemMore( commandline, StrLen(commandline) + 6 + StrLen(pathname));
  580.                 StrCat( commandline, " < ");
  581.                 StrCat( commandline, pathname);
  582.                 }
  583.             if (Stdout) {
  584.                 pathname= Fullpathname(Stdout,false);
  585.                 commandline= MemMore( commandline, StrLen(commandline) + 6 + StrLen(pathname));
  586.                 StrCat( commandline, " > ");
  587.                 StrCat( commandline, pathname);
  588.                 }
  589.             if (Stderr) {
  590.                 pathname= Fullpathname(Stderr,false);
  591.                 commandline= MemMore( commandline, StrLen(commandline) + 6 + StrLen(pathname));
  592.                 StrCat( commandline, " 2> ");
  593.                 StrCat( commandline, pathname);
  594.                 }
  595.             }
  596.  
  597. #ifdef WIN16
  598.         *lpszCmdLine= 0;
  599.         if (appName) { 
  600.         Nlm_StringNCpy( lpszCmdLine, appName, sizeof(lpszCmdLine));
  601.         Nlm_StringNCat( lpszCmdLine, " ", sizeof(lpszCmdLine));
  602.         }
  603.     Nlm_StringNCat( lpszCmdLine, commandline, sizeof(lpszCmdLine));
  604.     
  605.     val= WinExec (lpszCmdLine, SW_SHOW);
  606.     gChildProcessSN= val;
  607.     rsult= (val >= 32);
  608. #else
  609.     {
  610.     STARTUPINFO  si;
  611.     PROCESS_INFORMATION pri;
  612.     
  613.     memset(&pri, 0, sizeof(pri));
  614.     memset(&si, 0, sizeof(si));
  615.     si.cb= sizeof(si); /* !?? */
  616.     si.wShowWindow= SW_SHOW;
  617. #if 0
  618.         if (Stdin)  { freopen( Stdin, "r", stdin); si.hStdInput= stdin; }
  619.         if (Stdout) { freopen( Stdout, "a", stdout); si.hStdOutput= stdout; }
  620.         if (Stderr) { freopen( Stderr, "a", stderr); si.hStdError= stderr; }
  621.     si.dwFlags= STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES; 
  622. #else
  623.     si.dwFlags= 0; 
  624. #endif
  625.  
  626. #if 0
  627.       pathname= Fullpathname(appName,false);
  628.       ptail = pathname + StrLen(pathname) - 4;
  629.       if (StrICmp( ptail, ".exe") != 0)  StrCat( pathname, ".exe");
  630.     Nlm_StringNCpy( lpszCmdLine, commandline, sizeof(lpszCmdLine));
  631.     /* ! cmdline redirects are being intercepted by win-os ! */
  632.     rsult= CreateProcess( pathname, lpszCmdLine, NULL, NULL, true, 
  633. #else
  634.         *lpszCmdLine= 0;
  635.         if (appName) { 
  636.         Nlm_StringNCpy( lpszCmdLine, appName, sizeof(lpszCmdLine));
  637.         Nlm_StringNCat( lpszCmdLine, " ", sizeof(lpszCmdLine));
  638.         }
  639.     Nlm_StringNCat( lpszCmdLine, commandline, sizeof(lpszCmdLine));
  640.  
  641.     rsult= CreateProcess( NULL, lpszCmdLine, NULL, NULL, true, 
  642. #endif
  643.             DETACHED_PROCESS,/*CREATE_NEW_CONSOLE, */ 
  644.             NULL/*Env*/, 
  645.             NULL/*CurDir*/, 
  646.             &si, &pri);
  647.     if (rsult) {
  648.       gChildProcessSN= (long) pri.dwProcessId; /* hProcess ; */
  649.       }
  650.     }
  651. #endif
  652.   }
  653.   return rsult;
  654. #endif
  655.  
  656.  
  657. #ifdef WIN_MOTIF
  658.   Nlm_Boolean  rsult;
  659.   long              status;
  660.  
  661.   rsult = FALSE;
  662.   if ((appName && *appName) || (commandline && *commandline)) {
  663.     int          narg = 0, done;
  664.     char        *cmdline, **argv, *cp, *ep;
  665.     ulong     len;
  666.     
  667.         len= StrLen(appName) + StrLen(commandline) + 3;
  668.         cmdline= MemNew(len);
  669.         *cmdline= 0;
  670.         if (appName) { 
  671.             Nlm_StringCpy( cmdline, appName);
  672.             Nlm_StringCat( cmdline, " ");
  673.             }
  674.         Nlm_StringCat( cmdline, commandline);
  675.         
  676.        /* need to pop the cmdline args into a vector !*/
  677.     cp= cmdline; done= FALSE;
  678.     argv= (char**) Nlm_MemNew(sizeof(Nlm_CharPtr));
  679.     while (!done) {
  680.        while (*cp && *cp <= ' ') cp++;
  681.        if (*cp == '"') { for (ep= cp+1; *ep && *ep != '"'; ep++) ; }
  682.        else if (*cp == '\'') { for (ep= cp+1; *ep && *ep != '\''; ep++) ; }
  683.        else if (*cp) { for (ep= cp+1; *ep && *ep>' '; ep++) ; }
  684.        if (*ep) *ep= '\0';  else done= TRUE;
  685.        narg++;
  686.        argv= (char**) Nlm_MemMore(argv, (narg+1) * sizeof(Nlm_CharPtr));
  687. /*xdebugp("Dgg_LaunchFile argv[i]= %s\n",cp);*/
  688.        argv[narg-1]= cp;
  689.        cp= ep+1;
  690.        }
  691.     argv[narg]= NULL;
  692.  
  693. #ifdef OS_UNIX
  694.     status =  fork();
  695.     if (status == 0) {
  696.         /* if status==0, we are now the child process */
  697.             if (Stdin) { freopen( Stdin, "r", stdin); }
  698.             if (Stdout) { freopen( Stdout, "a", stdout); }
  699.             if (Stderr) { freopen( Stderr, "a", stderr); }
  700. #if 0
  701. /* DEBUG */
  702.             fprintf( stdout, "\n This is new stdout=%s\n",Stdout);
  703.             fprintf( stderr, "\n This is new stderr=%s\n",Stderr);
  704.             fprintf( stdout, "\n Dgg_LaunchApp(%s,%s,\n    %s,%s,%s);\n",
  705.                     appName,commandline, Stdin, Stdout, Stderr);
  706.             fprintf( stdout, " arg[0]=%s\n",argv[0]);
  707.             fflush( stdout); 
  708.             fflush( stderr);
  709.             /*_exit(-1); */        
  710. #endif
  711.       execvp( argv[0], argv);
  712.       /* if (stillhere) Nlm_Message (MSG_FATAL, "Application launch failed"); */
  713.       _exit(-1); /* app launch failed if we get here... */
  714.         } 
  715.     else if (status != -1) {
  716.         /* here status == child process id, need to save for child app handler */
  717.         gChildProcessSN= status;
  718.       rsult = TRUE;
  719.         }
  720.     else
  721.            Nlm_Message (MSG_OK, "Application launch failed");  
  722.  
  723. #endif
  724. #ifdef OS_VMS
  725.         /* ?? for VMS -- how do we change child process stdin/stdout/stderr ?? */
  726.     status = execvp( argv[0], argv);
  727.     if ( status == -1 ) {
  728.       /*Nlm_Message (MSG_FATAL, "Application launch failed"); */
  729.         } 
  730.     else {
  731.         gChildProcessSN= status;
  732.         /* here status == child process id, need to save for child app handler */
  733.       rsult = TRUE;
  734.         }
  735. #endif
  736.     Nlm_MemFree(cmdline);
  737.   }
  738.   return rsult;
  739. #endif
  740. }
  741.